package com.sparrow.common.ai.behaviortree.task.impl;

import com.sparrow.common.ai.behaviortree.def.BTNodeStatus;
import com.sparrow.common.ai.behaviortree.BehaviorContext;
import com.sparrow.common.ai.behaviortree.node.BehaviorNode;
import com.sparrow.common.ai.behaviortree.node.impl.ParallelNode;
import com.sparrow.common.ai.behaviortree.task.BehaviorTask;

import java.util.ArrayList;
import java.util.List;

/**
 * 并行节点（Parallel Node）语义说明
 * 执行方式：
 *  - 所有子任务都会被 Tick（同时执行）
 *  - 子任务完成（SUCCESS 或 FAILURE）后，不再 Tick 该子任务
 * 节点状态：
 *  - 如果任意子任务处于 RUNNING，则并行节点整体为 RUNNING (前提未完成)
 * 完成策略：
 *   1. FinishCondition = AnyTaskFinish：任意子任务完成（SUCCESS 或 FAILURE） → 并行节点完成
 *   2. FinishCondition = AllTasksFinish：所有子任务完成（SUCCESS 或 FAILURE） → 并行节点完成
 * 注意：
 *  - 成功/失败状态可以根据具体策略自定义
 */

public class ParallelTask extends BehaviorTask {

    /**
     * 完成策略
     */
    public enum FinishStrategy {
        /**
         * 任意子任务完成（SUCCESS 或 FAILURE） → 并行节点完成
         */
        ANY,
        /**
         * 所有子任务完成（SUCCESS 或 FAILURE） → 并行节点完成
         */
        ALL
    }

    private final List<BehaviorTask> childTasks = new ArrayList<>();
    private final List<BTNodeStatus> childStatus = new ArrayList<>();
    private final FinishStrategy finishStrategy;

    public ParallelTask(ParallelNode node, FinishStrategy finishStrategy) {
        this.finishStrategy = finishStrategy;
        for (BehaviorNode child : node.getChildren()) {
            BehaviorTask task = child.createTask();
            this.childTasks.add(task);
            this.childStatus.add(BTNodeStatus.RUNNING); // 初始状态
        }
    }

    @Override
    public BTNodeStatus tick(BehaviorContext context, long now, long delta) {
        boolean anyRunning = false;
        boolean anySuccess = false;
        boolean anyFailure = false;

        for (int i = 0; i < childTasks.size(); i++) {
            BehaviorTask task = childTasks.get(i);
            BTNodeStatus status = childStatus.get(i);
            // 已完成的子任务不再 Tick
            if (status == BTNodeStatus.RUNNING) {
                status = task.tick(context, now, delta);
                childStatus.set(i, status);
            }

            switch (status) {
                case RUNNING : {
                    anyRunning = true;
                    break;
                }
                case SUCCESS : {
                    anySuccess = true;
                    break;
                }
                case FAILURE : {
                    anyFailure = true;
                    break;
                }
            }
        }

        // 根据 FinishCondition 返回整体状态
        switch (finishStrategy) {
            case ANY: {
                if (anySuccess) {
                    return BTNodeStatus.SUCCESS;
                }
                if (anyFailure) {
                    return BTNodeStatus.FAILURE;
                }
                return BTNodeStatus.RUNNING;
            }
            case ALL: {
                if (!anyRunning) {
                    // 所有子任务完成后返回状态，可自定义策略
                    if (anyFailure) {
                        return BTNodeStatus.FAILURE;
                    }
                    return BTNodeStatus.SUCCESS;
                }
                return BTNodeStatus.RUNNING;
            }
        }

        return BTNodeStatus.RUNNING;
    }

    @Override
    public void reset() {
        for (BehaviorTask task : childTasks) {
            task.reset();
        }
        for (int i = 0; i < childStatus.size(); i++) {
            childStatus.set(i, BTNodeStatus.RUNNING);
        }
    }

    @Override
    public String toString() {
        return "ParallelTask{" +
                "childTasks=" + childTasks +
                ", childStatus=" + childStatus +
                ", finishStrategy=" + finishStrategy +
                '}';
    }
}
